/* generated using openapi-typescript-codegen -- do no edit */
/* istanbul ignore file */
/* tslint:disable */
/* eslint-disable */
import type { CheckOutDto } from '../models/CheckOutDto';
import type { RentDetaioDto } from '../models/RentDetaioDto';
import type { Result } from '../models/Result';
import type { RoomManage_ } from '../models/RoomManage_';
import type { RoomRequestParam } from '../models/RoomRequestParam';

import type { CancelablePromise } from '../core/CancelablePromise';
import { OpenAPI } from '../core/OpenAPI';
import { request as __request } from '../core/request';

export class RoomManageControllerService {

    /**
     * addManage
     * @param roomManage roomManage
     * @returns Result OK
     * @returns any Created
     * @throws ApiError
     */
    public static addManageUsingPost(
roomManage: RoomManage_,
): CancelablePromise<Result | any> {
        return __request(OpenAPI, {
            method: 'POST',
            url: '/room-manage/add',
            body: roomManage,
            errors: {
                401: `Unauthorized`,
                403: `Forbidden`,
                404: `Not Found`,
            },
        });
    }

    /**
     * customerCheckOut
     * @param checkOutDto checkOutDto
     * @returns Result OK
     * @returns any Created
     * @throws ApiError
     */
    public static customerCheckOutUsingPost(
checkOutDto: CheckOutDto,
): CancelablePromise<Result | any> {
        return __request(OpenAPI, {
            method: 'POST',
            url: '/room-manage/checkOut',
            body: checkOutDto,
            errors: {
                401: `Unauthorized`,
                403: `Forbidden`,
                404: `Not Found`,
            },
        });
    }

    /**
     * deleteManage
     * @param id id
     * @returns Result OK
     * @throws ApiError
     */
    public static deleteManageUsingGet(
id: string,
): CancelablePromise<Result> {
        return __request(OpenAPI, {
            method: 'GET',
            url: '/room-manage/delete/{id}',
            path: {
                'id': id,
            },
            errors: {
                401: `Unauthorized`,
                403: `Forbidden`,
                404: `Not Found`,
            },
        });
    }

    /**
     * getDetail
     * @param id id
     * @returns Result OK
     * @throws ApiError
     */
    public static getDetailUsingGet(
id: string,
): CancelablePromise<Result> {
        return __request(OpenAPI, {
            method: 'GET',
            url: '/room-manage/getDetail/{id}',
            path: {
                'id': id,
            },
            errors: {
                401: `Unauthorized`,
                403: `Forbidden`,
                404: `Not Found`,
            },
        });
    }

    /**
     * listPage
     * @param roomRequestParam roomRequestParam
     * @returns Result OK
     * @returns any Created
     * @throws ApiError
     */
    public static listPageUsingPost1(
roomRequestParam: RoomRequestParam,
): CancelablePromise<Result | any> {
        return __request(OpenAPI, {
            method: 'POST',
            url: '/room-manage/listPage',
            body: roomRequestParam,
            errors: {
                401: `Unauthorized`,
                403: `Forbidden`,
                404: `Not Found`,
            },
        });
    }

    /**
     * customerRent
     * @param rentDetaioDto rentDetaioDto
     * @returns Result OK
     * @returns any Created
     * @throws ApiError
     */
    public static customerRentUsingPost(
rentDetaioDto: RentDetaioDto,
): CancelablePromise<Result | any> {
        return __request(OpenAPI, {
            method: 'POST',
            url: '/room-manage/rent',
            body: rentDetaioDto,
            errors: {
                401: `Unauthorized`,
                403: `Forbidden`,
                404: `Not Found`,
            },
        });
    }

    /**
     * updateManage
     * @param roomManage roomManage
     * @returns Result OK
     * @returns any Created
     * @throws ApiError
     */
    public static updateManageUsingPost(
roomManage: RoomManage_,
): CancelablePromise<Result | any> {
        return __request(OpenAPI, {
            method: 'POST',
            url: '/room-manage/update',
            body: roomManage,
            errors: {
                401: `Unauthorized`,
                403: `Forbidden`,
                404: `Not Found`,
            },
        });
    }

}
